// 5614. 找出最具竞争力的子序列
function mostCompetitive(nums: number[], k: number): number[] {
    let len = nums.length
    let start = 0
    let last = len - k    //第一个元素可能的最后一个位置
    let first = nums[0]
    let index = 0
    let ans:number[] = []
    while(k>0){
        /**
         * 这里可以用单调栈进行优化，每次就不用都从头开始了
         * 
         * 单调栈就适合这种后面小的话，前面就都没用了
         */
        for(let i=start+1;i<=last;i++){
            if(nums[i]<first){
                first = nums[i]
                index = i
            }
        }
        ans.push(first)
        k--
        start = index+1
        last = len - k    //第一个元素可能的最后一个位置
        first = nums[start] || 0
        index = start
    }
    return ans
    
};


//5615. 使数组互补的最少操作次数
function minMoves(nums: number[], limit: number): number {

    //超时

    function test(index:number,nums:number[],limit:number):number{
        let times = 0
        for(let i = 0;i<nums.length/2;i++){
            let l = nums[i]
            let r = nums[nums.length-1-i]
            let sum = l + r 
            if(sum>index){
                l = Math.min(l,r)
                if(l+1<=index) times++
                else times+=2
            }else if(sum<index){
                r = Math.max(l,r)
                if(r+limit>=index) times++
                else times+=2
            }
        }
        return times
    }

    const set = new Set<number>()
    //枚举两个数的和
    for(let i=0;i<nums.length/2;i++){
        set.add(nums[i]+nums[nums.length-1-i])
    }
    let min = 1e6
    for(let i of set){
        min = Math.min(min,test(i,nums,limit))
    }
   return min
    
};